Перейти к основному содержимому

5.09. Экосистема Kotlin-приложений

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Экосистема Kotlin-приложений​

Kotlin — это язык программирования, созданный компанией JetBrains с целью сочетать выразительность, безопасность и совместимость с существующими экосистемами. За годы своего развития он стал не просто альтернативой Java на платформе JVM, но и самостоятельной основой для создания приложений на множестве платформ: Android, iOS, сервер, браузер, десктоп и даже встраиваемые системы. Эта глава описывает полную картину современной экосистемы Kotlin-приложений — от пользовательских интерфейсов до серверных служб, от тестирования до экспериментальных направлений.

1. Прикладные фреймворки и клиентские приложения​

Клиентская разработка на Kotlin охватывает широкий спектр устройств и сред: мобильные телефоны, планшеты, десктопные компьютеры, веб-браузеры. Основу этой части экосистемы составляют официальные и сообщественные инструменты, ориентированные на удобство, производительность и единый стиль кода.

Android SDK с Kotlin​

Android SDK — это набор библиотек и инструментов, предоставляемых Google для создания приложений под операционную систему Android. Kotlin стал официальным языком разработки Android в 2017 году и с тех пор глубоко интегрирован в эту платформу.

Kotlin идеально подходит для Android благодаря своей компактности, null-safety и расширяемости. Он позволяет писать меньше шаблонного кода по сравнению с Java, а также использовать лямбда-выражения, делегированные свойства и extension-функции для упрощения работы с API Android.

Пример простого Activity на Kotlin:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val button = findViewById<Button>(R.id.button)
        button.setOnClickListener {
            Toast.makeText(this, "Привет из Kotlin!", Toast.LENGTH_SHORT).show()
        }
    }
}

Этот код демонстрирует типичное взаимодействие с UI-элементами через View Binding или findViewById, обработку событий через лямбды и использование стандартных Android-компонентов. Kotlin делает такой код читаемым и лаконичным.

Jetpack Compose​

Jetpack Compose — это современный декларативный UI-фреймворк для Android, полностью написанный на Kotlin. Он заменяет традиционную XML-разметку и императивное управление View-элементами новой моделью, основанной на функциях, аннотациях и состояниях.

Compose работает на принципе пересоздания UI при изменении данных. Каждый UI-компонент — это обычная Kotlin-функция, помеченная аннотацией @Composable. Такой подход позволяет строить интерфейсы как дерево функций, где каждая функция отвечает за отображение определённого фрагмента экрана.

Пример компонента:

@Composable
fun Greeting(name: String) {
    Text(text = "Привет, $name!")
}

@Composable
fun MyApp() {
    MaterialTheme {
        Surface {
            Greeting("Анна")
        }
    }
}

Compose использует механизм recomposition: при изменении входных параметров (name) вызывается повторная отрисовка только затронутых частей дерева. Это обеспечивает высокую производительность и предсказуемое поведение.

ViewModel, LiveData, Room, Navigation​

Эти компоненты входят в состав Android Jetpack — набора библиотек, рекомендованных Google для построения надёжных и масштабируемых приложений.

ViewModel сохраняет данные, связанные с UI, и переживает изменения конфигурации (например, поворот экрана). Он изолирует логику представления от активности жизненного цикла Activity или Fragment.

LiveData — это observable-контейнер, который уведомляет подписчиков об изменениях только тогда, когда они находятся в активном состоянии. Это предотвращает утечки памяти и ошибки жизненного цикла.

Room — это ORM-библиотека поверх SQLite, предоставляющая удобный способ работы с локальной базой данных. Она использует аннотации для описания сущностей, DAO и миграций.

Пример сущности и DAO:

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): LiveData<List<User>>

    @Insert
    suspend fun insert(user: User)
}

Navigation — это фреймворк для управления переходами между экранами в приложении. Он использует граф навигации, описанный в XML или программно, и поддерживает deep links, анимации и безопасные аргументы.

Все эти компоненты работают в связке и образуют основу архитектурного подхода, рекомендованного Google: MVVM (Model–View–ViewModel).

Coroutines и Flow​

Kotlin Coroutines — это библиотека для асинхронного программирования, встроенная в язык на уровне стандартной библиотеки. Они позволяют писать асинхронный код в виде последовательных блоков без callback-адов и сложных цепочек.

Coroutines управляются через CoroutineScope, launch и async. Для Android особенно важна интеграция с жизненным циклом через lifecycleScope и viewModelScope.

Flow — это реактивный поток данных, аналог RxJava Observable, но нативный для Kotlin. Он холодный (не запускается, пока на него не подписаны), поддерживает отмену и корректно работает с корутинами.

Пример использования Flow для загрузки данных:

fun observeUsers(): Flow<List<User>> = flow {
    val users = userRepository.getAll()
    emit(users)
}.flowOn(Dispatchers.IO)

Flow часто используется в связке с Room, Retrofit и другими источниками данных для построения реактивных цепочек обработки.

Ktor Client​

Ktor Client — это кроссплатформенная HTTP-библиотека от JetBrains, предназначенная для выполнения сетевых запросов. Она поддерживает JVM, Android, iOS, JavaScript и Native.

Ktor Client использует DSL-стиль конфигурации и легко расширяется плагинами: JSON-сериализация, логирование, авторизация, кэширование.

Пример запроса:

val client = HttpClient(CIO) {
    install(ContentNegotiation) {
        json()
    }
}

val response: User = client.get("https://api.example.com/user/1")

Ktor Client особенно ценен в мультиплатформенных проектах, где один и тот же код может выполняться на разных платформах без изменений.

Compose Multiplatform​

Compose Multiplatform — это расширение Jetpack Compose за пределы Android. Оно позволяет использовать один и тот же декларативный UI-код для Android, iOS, десктопа (Windows, macOS, Linux) и даже веба (в экспериментальном режиме).

Основа Compose Multiplatform — это общая логика UI, написанная на Kotlin Multiplatform, и нативные рендереры для каждой платформы. Это достигается через Skia — кросс-платформенный графический движок от Google.

Пример кроссплатформенного экрана:

@Composable
fun SharedApp() {
    var text by remember { mutableStateOf("Привет") }

    Column {
        Text(text)
        Button(onClick = { text = "Обновлено!" }) {
            Text("Нажми меня")
        }
    }
}

Такой код компилируется в нативное приложение на каждой целевой платформе, сохраняя внешний вид и поведение. Это значительно ускоряет разработку и снижает дублирование кода.

TornadoFX​

TornadoFX — это Kotlin-обёртка над JavaFX, популярной библиотекой для создания десктопных приложений на JVM. Хотя JavaFX сам по себе мощный, TornadoFX добавляет Kotlin-специфические возможности: type-safe builders, делегированные свойства для привязки данных, корутины для фоновых задач.

Пример окна на TornadoFX:

class HelloWorld : View("Приветствие") {
    override val root = vbox {
        label("Привет, мир!")
        button("Нажми") {
            action { println("Кнопка нажата") }
        }
    }
}

TornadoFX остаётся актуальным решением для enterprise-десктопных приложений, особенно там, где требуется плотная интеграция с JVM-библиотеками.

Kotlin-DSL​

Kotlin DSL (Domain Specific Language) — это не отдельная библиотека, а подход к созданию выразительных API с использованием возможностей Kotlin: лямбд с приёмником, extension-функций, infix-операторов.

Многие библиотеки в экосистеме Kotlin используют DSL: Gradle, Ktor, Compose, kotlinx.html. Это делает конфигурацию и описание структур похожими на естественный язык.

Пример DSL в Ktor Server:

routing {
    get("/hello") {
        call.respondText("Привет из Ktor!")
    }
}

Такой стиль улучшает читаемость и уменьшает количество шаблонного кода.

Skiko / Skia + Kotlin​

Skiko — это Kotlin-обёртка над Skia, графической библиотекой, используемой в Chrome, Flutter и Android. Она предоставляет низкоуровневый доступ к 2D-рендерингу: рисование фигур, текста, изображений, применение трансформаций и эффектов.

Skiko используется как основа для Compose Multiplatform и может применяться напрямую для создания кастомных графических приложений: редакторов, визуализаций, игр.

Пример рисования:

val surface = SkiaWindow().apply { show() }
surface.onRender = { canvas ->
    canvas.clear(Color.White)
    canvas.drawRect(Rect(50f, 50f, 200f, 150f), Paint().apply {
        color = Color.Blue
    })
}

Skiko даёт полный контроль над графикой и работает на всех поддерживаемых платформах Kotlin.

2. Серверные и фоновые службы​

Kotlin активно используется для разработки серверных приложений, микросервисов, фоновых задач и обработчиков событий. Благодаря совместимости с JVM, поддержке корутин и растущему числу нативных фреймворков, Kotlin стал зрелым выбором для backend-разработки. Экосистема предлагает как легковесные решения, так и полноценные enterprise-платформы.

Ktor​

Ktor — это асинхронный веб-фреймворк, разработанный JetBrains специально для Kotlin. Он построен на принципах модульности, расширяемости и кроссплатформенности. Ktor поддерживает JVM, Android, iOS, JavaScript и даже Native через Kotlin Multiplatform.

Основные компоненты Ktor:

  • Application Engine — запускает сервер (Netty, CIO, Jetty, Tomcat).
  • Routing — определяет обработчики HTTP-запросов.
  • Plugins — расширяют функциональность: сериализация, аутентификация, CORS, логирование.
  • Client и Server — единый API для обеих сторон взаимодействия.

Пример простого сервера:

fun main() {
    embeddedServer(Netty, port = 8080) {
        routing {
            get("/hello") {
                call.respondText("Привет из Ktor!")
            }
            post("/user") {
                val user = call.receive<User>()
                call.respond(user.copy(id = 1))
            }
        }
    }.start(wait = true)
}

Ktor использует корутины для обработки запросов, что делает его высокоэффективным при высокой нагрузке. Он не навязывает архитектурные паттерны, предоставляя разработчику свободу выбора.

Spring Boot с Kotlin​

Spring Boot — один из самых популярных Java-фреймворков для enterprise-разработки. Он полностью совместим с Kotlin и предоставляет первоклассную поддержку языка начиная с версии 5.0.

Kotlin в Spring Boot позволяет:

  • Использовать data-классы вместо POJO.
  • Применять null-safety для защиты от NullPointerException.
  • Писать конфигурацию через @Configuration и DSL.
  • Использовать extension-функции для упрощения работы с шаблонами (например, Thymeleaf).

Пример контроллера:

@RestController
class UserController(
    private val userService: UserService
) {
    @GetMapping("/users/{id}")
    fun getUser(@PathVariable id: Long): UserDto =
        userService.findById(id).toDto()
}

Spring Boot с Kotlin сохраняет всю мощь Spring (DI, AOP, Security, Data, Cloud), но делает код более лаконичным и безопасным. Особенно удобна интеграция с Spring WebFlux для реактивного программирования.

http4k​

http4k — это функциональный, легковесный фреймворк для создания HTTP-сервисов без зависимостей от серверных контейнеров. Он основан на трёх ключевых концепциях:

  • HttpHandler — функция (Request) -> Response.
  • Filters — композируемые преобразователи запросов и ответов.
  • Lens — безопасные способы извлечения и вставки данных в HTTP-сообщения.

http4k работает на любом JVM-совместимом сервере и может быть упакован в standalone JAR или даже в AWS Lambda.

Пример сервиса:

val app: HttpHandler = {
    when (it.method to it.uri.path) {
        GET to "/ping" -> Response(OK).body("pong")
        else -> Response(NOT_FOUND)
    }
}

fun main() {
    val server = SunHttp(8000).toServer(app).start()
}

http4k особенно популярен в средах с требованием к минимальному размеру образа, быстрому запуску и функциональной чистоте.

Quarkus / Micronaut с Kotlin​

Quarkus и Micronaut — это современные фреймворки, ориентированные на облачные среды, микросервисы и native-компиляцию через GraalVM.

Quarkus использует compile-time DI и агрессивную оптимизацию для достижения мгновенного запуска и низкого потребления памяти. Он поддерживает Kotlin через специальные расширения и позволяет писать реактивные и блокирующие сервисы в одном приложении.

Micronaut также делает акцент на времени запуска и потреблении ресурсов. Он генерирует метаданные во время компиляции, что исключает рефлексию в runtime. Это делает его идеальным для serverless-сред.

Оба фреймворка позволяют использовать Kotlin-специфические возможности: data-классы, sealed-классы, корутины (в Quarkus — с ограничениями), и легко интегрируются с Kafka, PostgreSQL, Redis и другими cloud-native технологиями.

Пример контроллера в Micronaut:

@Controller("/api")
class GreetingController {
    @Get("/hello/{name}")
    fun hello(name: String): String = "Привет, $name!"
}

Эти фреймворки подходят для проектов, где важны скорость запуска, малый footprint и готовность к работе в Kubernetes или FaaS.

Ktor Server + Workers​

Помимо традиционных HTTP-серверов, Kotlin используется для написания фоновых служб — обработчиков очередей, планировщиков задач, stream-процессоров. Ktor Server может работать в связке с такими системами, но часто используются и другие подходы.

Например, Ktor Workers — это экспериментальный механизм (внутри Ktor или как отдельная библиотека) для выполнения длительных задач в фоне с возможностью отслеживания состояния, повторных попыток и распределения нагрузки.

Более распространённый путь — использование Kotlin Coroutines вместе с библиотеками вроде Kafka Streams, RabbitMQ Client, Redis Streams или Project Reactor. Корутины позволяют эффективно управлять тысячами одновременных задач без перегрузки потоков.

Пример фонового обработчика:

fun startBackgroundWorker(scope: CoroutineScope) {
    scope.launch {
        while (isActive) {
            val job = fetchPendingJob()
            if (job != null) {
                processJob(job)
                markAsCompleted(job.id)
            } else {
                delay(1000)
            }
        }
    }
}

Такие службы легко масштабируются, тестируются и интегрируются с мониторинговыми системами через метрики и логи.

3. Тестовые и вспомогательные проекты​

Тестирование — неотъемлемая часть разработки на Kotlin. Экосистема предоставляет богатый набор фреймворков, адаптированных под особенности языка: корутины, sealed-классы, extension-функции, null-safety. Эти инструменты позволяют писать выразительные, читаемые и надёжные тесты без избыточного шаблонного кода.

Kotest (ранее KotlinTest)​

Kotest — это полноценный фреймворк для unit-, интеграционного и property-based тестирования, написанный специально для Kotlin. Он поддерживает несколько стилей написания тестов: FunSpec, DescribeSpec, BehaviorSpec, FreeSpec и другие, что позволяет выбрать наиболее подходящий стиль под команду или проект.

Kotest интегрируется с JUnit 5, предоставляет мощные assertion-библиотеки, встроенные matchers, поддержку корутин и асинхронных тестов.

Пример теста в стиле FunSpec:

class UserServiceTest : FunSpec({
    test("пользователь с валидным email сохраняется") {
        val user = User(email = "test@example.com")
        val result = userService.save(user)
        result.id shouldNotBe null
        result.email shouldBe "test@example.com"
    }

    context("при недопустимом email") {
        test("выбрасывается исключение") {
            val invalidUser = User(email = "invalid")
            shouldThrow<ValidationException> {
                userService.save(invalidUser)
            }
        }
    }
})

Kotest поддерживает параметризованные тесты, теги, условное выполнение, вложенные контексты и автоматическую генерацию данных через property-based testing. Это делает его гибким инструментом как для простых проверок, так и для сложных сценариев.

Spek​

Spek — это ещё один BDD-ориентированный фреймворк для тестирования на Kotlin. Он использует DSL, похожий на RSpec из мира Ruby, и строит тесты как дерево описаний и примеров.

Spek работает поверх JUnit Platform и поддерживает корутины через специальные расширения.

Пример:

object CalculatorSpec : Spek({
    describe("калькулятор") {
        val calculator by memoized { Calculator() }

        it("складывает два числа") {
            assertEquals(4, calculator.add(2, 2))
        }

        it("умножает два числа") {
            assertEquals(6, calculator.multiply(2, 3))
        }
    }
})

Spek особенно популярен в командах, придерживающихся поведенческого подхода к тестированию, где важна читаемость и соответствие бизнес-требованиям.

MockK​

MockK — это mocking-библиотека, созданная специально для Kotlin. Она поддерживает все особенности языка: final-классы, объекты, extension-функции, suspend-функции, inline-классы.

В отличие от Mockito, MockK не требует open-классов или специальных настроек для моков. Он использует байткод-инструментацию для создания моков даже из закрытых классов.

Пример мока:

val userRepository = mockk<UserRepository>()
every { userRepository.findById(1L) } returns User(id = 1L, name = "Анна")

val service = UserService(userRepository)
val user = service.getUser(1L)

assertEquals("Анна", user.name)
verify { userRepository.findById(1L) }

Для suspend-функций используется тот же синтаксис:

every { userRepository.save(any()) } coAnswers { User(id = 42, name = "Новый") }

MockK также поддерживает spy-объекты, частичные моки, цепочки вызовов и верификацию порядка.

Strikt​

Strikt — это assertion-библиотека, ориентированная на читаемость и композицию. Она использует fluent API и позволяет строить сложные проверки в виде цепочек.

Strikt особенно удобен при работе с вложенными структурами данных, коллекциями и результатами парсинга.

Пример:

expectThat(user)
    .get { name }.isEqualTo("Мария")
    .get { email }.contains("@")
    .get { preferences.theme }.isEqualTo("dark")

Strikt поддерживает кастомные assertion-функции, что позволяет расширять его под нужды домена.

Turbine​

Turbine — это утилита для тестирования Kotlin Flow. Она предоставляет простой способ собирать события из потока и проверять их последовательность, значения и завершение.

Без Turbine тестирование Flow требует ручного управления каналами и корутинами. Turbine абстрагирует эту сложность.

Пример:

@Test
fun `наблюдение за пользователями`() = runTest {
    val flow = repository.observeUsers()
    flow.test {
        assertEquals(User(id = 1, name = "Иван"), awaitItem())
        assertEquals(User(id = 2, name = "Ольга"), awaitItem())
        awaitComplete()
    }
}

Turbine корректно обрабатывает ошибки, отмену и задержки, что делает его незаменимым при тестировании реактивных цепочек.

AndroidX Test, Espresso, Compose Testing​

Для Android-приложений Kotlin-экосистема предлагает три уровня UI-тестирования:

  • AndroidX Test — набор базовых инструментов для unit- и интеграционных тестов на устройстве или эмуляторе.
  • Espresso — фреймворк для end-to-end тестирования View-интерфейсов. Он синхронизируется с UI-потоком и гарантирует стабильность тестов.
  • Compose Testing — официальный инструмент для тестирования Jetpack Compose. Он позволяет находить элементы по семантике, выполнять действия и проверять состояние.

Пример Compose-теста:

@Test
fun greeting_shows_name() {
    composeTestRule.setContent {
        Greeting("Елена")
    }

    composeTestRule.onNodeWithText("Привет, Елена!").assertExists()
}

Compose Testing использует ту же модель, что и сам Compose: декларативность, иерархия и семантические метки. Это делает тесты устойчивыми к изменениям в реализации UI.

Все эти инструменты интегрируются с Gradle, CI/CD-системами и предоставляют отчёты в стандартных форматах.

4. Интеграционные и специализированные платформы​

Современные Kotlin-приложения редко состоят из изолированных модулей. Они взаимодействуют с внешними API, базами данных, файловыми системами, другими микросервисами. Для этого экосистема предоставляет набор инструментов, ориентированных на безопасность типов, производительность и кроссплатформенность.

kotlinx.serialization​

kotlinx.serialization — это официальная библиотека сериализации от JetBrains, полностью интегрированная в компилятор Kotlin. Она поддерживает JSON, Protobuf, CBOR, Properties и другие форматы, а также работает на всех платформах: JVM, Android, iOS, JS, Native.

Основное преимущество — отсутствие рефлексии. Сериализация происходит во время компиляции через плагин компилятора, что делает её быстрой и совместимой с native-компиляцией (GraalVM, Kotlin/Native).

Пример:

@Serializable
data class User(val id: Int, val name: String)

val json = Json.encodeToString(User(42, "Дмитрий"))
val user = Json.decodeFromString<User>(json)

Библиотека поддерживает полиморфизм, кастомные сериализаторы, игнорирование полей, преобразование ключей и вложенные структуры. Она является стандартом де-факто для Ktor, Compose Multiplatform и других мультиплатформенных решений.

Koin / Kodein​

Koin и Kodein — это лёгкие контейнеры внедрения зависимостей (DI), написанные специально для Kotlin. В отличие от Spring или Dagger, они не используют аннотации процессора или рефлексию, а строятся на DSL и функциональных возможностях языка.

Koin особенно популярен в Android- и Ktor-проектах благодаря простоте настройки и интеграции.

Пример определения зависимостей в Koin:

val appModule = module {
    single { DatabaseDriver() }
    single { UserRepository(get()) }
    factory { UserService(get()) }
}

// В приложении
startKoin {
    modules(appModule)
}

Получение зависимости:

class UserController : Controller() {
    private val userService by inject<UserService>()
}

Koin поддерживает scope-зависимости, свойства, корутины и мультиплатформенность. Он идеально подходит для проектов, где важна скорость запуска и минимальный размер.

Kodein предлагает похожий подход, но с более гибкой моделью конфигурации и поддержкой type-erasure обхода через reified-типы.

Обе библиотеки позволяют писать тестируемый код без жёсткой связности.

SQLDelight​

SQLDelight — это ORM-библиотека, которая компилирует SQL-запросы в типобезопасный Kotlin-код. Она проверяет синтаксис запросов на этапе компиляции и генерирует data-классы для результатов.

SQLDelight поддерживает SQLite, MySQL, PostgreSQL, HSQL и другие диалекты. Особенно она популярна в Android и Kotlin Multiplatform Mobile (KMM), где обеспечивает единый слой доступа к данным на всех платформах.

Пример .sq-файла:

selectAll:
SELECT *
FROM users;

insertUser:
INSERT INTO users(id, name)
VALUES (?, ?);

Генерируется Kotlin-код:

val users: Query<User> = database.userQueries.selectAll()
database.userQueries.insertUser(1, "Артём")

SQLDelight работает с Coroutines и Flow, предоставляя реактивные потоки изменений. Это делает его мощным инструментом для offline-first приложений.

Realm Kotlin SDK​

Realm — это объектная база данных в реальном времени, изначально разработанная для мобильных платформ. Realm Kotlin SDK — это нативная реализация для Kotlin Multiplatform, заменившая старые Java- и Swift-обёртки.

Она позволяет работать с объектами напрямую, без SQL, и автоматически синхронизирует изменения между устройствами через облачный сервис.

Пример модели:

class User : RealmObject {
    var id: Long = 0
    var name: String = ""
}

Запись и чтение:

realm.write {
    copyToRealm(User().apply { id = 1; name = "София" })
}

val users = realm.query<User>("name == $0", "София").find()

Realm Kotlin SDK поддерживает реактивные запросы, миграции, шифрование и работает на Android, iOS и десктопе.

Arrow​

Arrow — это библиотека для функционального программирования на Kotlin. Она предоставляет типы данных, абстракции и паттерны, характерные для Haskell, Scala и других ФП-языков: Option, Either, IO, State, Reader, Monad, Applicative.

Arrow помогает управлять эффектами, ошибками и асинхронностью в чистом функциональном стиле.

Пример обработки ошибок:

fun fetchUser(id: Int): Either<Error, User> =
    if (id > 0) Right(User(id, "Кира"))
    else Left(Error.InvalidId)

val result = fetchUser(5)
    .map { user -> user.copy(name = user.name.uppercase()) }
    .fold(
        ifLeft = { println("Ошибка: ${it.message}") },
        ifRight = { println("Имя: ${it.name}") }
    )

Arrow Core интегрируется с Coroutines через Arrow Fx Coroutines, позволяя писать функциональный код с suspend-функциями. Библиотека особенно ценна в проектах, где важна предсказуемость, композируемость и явное управление побочными эффектами.

Kotlin Multiplatform Mobile (KMM)​

Kotlin Multiplatform Mobile — это технология от JetBrains для совместного использования бизнес-логики между Android и iOS. Она позволяет писать общий код на Kotlin, который компилируется в JVM-байткод для Android и в native-библиотеку для iOS.

KMM не заменяет UI-фреймворки — он фокусируется на слое данных, сети, логики и утилит. UI остаётся нативным: Jetpack Compose или SwiftUI.

Структура типичного KMM-проекта:

shared/
├── src/
│   ├── commonMain/      // общий код
│   ├── androidMain/     // Android-специфика
│   └── iosMain/         // iOS-специфика

Пример общего репозитория:

// commonMain
expect class PlatformLogger() {
    fun log(message: String)
}

class UserRepository(private val logger: PlatformLogger) {
    fun loadUser(): User {
        logger.log("Загрузка пользователя...")
        return api.fetchUser()
    }
}

Реализации:

// androidMain
actual class PlatformLogger actual constructor() {
    actual fun log(message: String) {
        android.util.Log.d("Shared", message)
    }
}

// iosMain
actual class PlatformLogger actual constructor() {
    actual fun log(message: String) {
        NSLog(message)
    }
}

KMM активно используется в production-приложениях (например, Netflix, Philips, BMW) и поддерживается официальными библиотеками: Ktor Client, kotlinx.serialization, SQLDelight, Coroutines.

5. Расширения и инструменты разработки​

Эффективная разработка на Kotlin невозможна без зрелой инфраструктуры: системы сборки, компиляторных целей, генераторов документации, линтеров. Экосистема Kotlin предоставляет официальные и сообщественные инструменты, глубоко интегрированные в язык и поддерживающие мультиплатформенный подход.

Gradle с Kotlin DSL​

Gradle — это система автоматизации сборки, доминирующая в JVM-мире. Kotlin DSL (Domain Specific Language) — это способ написания скриптов сборки на самом Kotlin вместо Groovy.

Преимущества Kotlin DSL:

  • Типобезопасность: ошибки в конфигурации обнаруживаются на этапе компиляции.
  • Поддержка IDE: автодополнение, навигация, рефакторинг.
  • Выразительность: использование всех возможностей Kotlin — extension-функций, делегатов, data-классов.

Пример build.gradle.kts:

plugins {
    kotlin("multiplatform") version "2.0.0"
    id("com.android.library")
}

kotlin {
    androidTarget()
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("io.ktor:ktor-client-core:2.3.12")
            implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
        }
        androidMain.dependencies {
            implementation("io.ktor:ktor-client-okhttp:2.3.12")
        }
        iosMain.dependencies {
            implementation("io.ktor:ktor-client-darwin:2.3.12")
        }
    }
}

Kotlin DSL особенно важен в мультиплатформенных проектах, где требуется точное управление зависимостями и источниками для каждой цели. Он делает конфигурацию предсказуемой и поддерживаемой.

kotlinx.coroutines​

kotlinx.coroutines — это библиотека для асинхронного и параллельного программирования, встроенная в стандартную экосистему Kotlin. Она предоставляет корутины — легковесные потоки выполнения, управляемые пользователем.

Ключевые понятия:

  • CoroutineScope — контекст, в котором запускаются корутины.
  • Dispatcher — определяет поток или пул потоков для выполнения (Main, IO, Default, Unconfined).
  • Job — задача, которую можно отменить.
  • Deferred — отложенный результат (аналог Future/Promise).
  • Flow — реактивный поток данных.

Пример фоновой загрузки:

viewModelScope.launch(Dispatchers.IO) {
    try {
        val data = repository.loadData()
        _uiState.value = UiState.Success(data)
    } catch (e: Exception) {
        _uiState.value = UiState.Error(e.message ?: "Неизвестная ошибка")
    }
}

Библиотека интегрируется со всеми частями экосистемы: Android Lifecycle, Ktor, Reactor, Project Loom. Она является основой для современного асинхронного кода на Kotlin.

Kotlin/Native​

Kotlin/Native — это компилятор Kotlin в машинный код без виртуальной машины. Он использует технологию LLVM и предназначен для платформ, где JVM недоступна: iOS, macOS, embedded-устройства, серверные среды с ограничениями.

Особенности Kotlin/Native:

  • Отсутствие garbage collector (используется ARC — automatic reference counting).
  • Совместимость с C-библиотеками через cinterop.
  • Поддержка мультиплатформенных проектов через общие исходники.

Пример вызова C-функции:

// В commonMain
expect fun getCurrentTime(): String

// В iosMain
actual fun getCurrentTime(): String {
    return NSDate().description()
}

Kotlin/Native лежит в основе Kotlin Multiplatform Mobile и используется в десктопных приложениях через Compose Multiplatform.

Kotlin/JS​

Kotlin/JS — это компилятор Kotlin в JavaScript. Он позволяет писать клиентский код на Kotlin и запускать его в браузере или Node.js.

Существует два режима:

  • Legacy — старый компилятор с полной совместимостью с JS-экосистемой.
  • IR (Intermediate Representation) — новый компилятор с улучшенной производительностью, tree-shaking и поддержкой DCE (dead code elimination).

Kotlin/JS интегрируется с npm, webpack, React, Vue и другими фронтенд-инструментами. Он особенно полезен в full-stack Kotlin-проектах, где бизнес-логика может быть общей.

Пример React-компонента на Kotlin/JS:

external interface Props : RProps {
    var name: String
}

val helloComponent = functionalComponent<Props> { props ->
    h1 { +"Привет, ${props.name}!" }
}

Хотя Kotlin/JS менее популярен, чем Kotlin/JVM или Kotlin/Native, он остаётся важной частью кроссплатформенной стратегии.

Dokka​

Dokka — это официальный генератор документации для Kotlin, аналог Javadoc. Он поддерживает все платформы Kotlin и умеет объединять документацию из нескольких модулей.

Dokka читает KDoc-комментарии (Kotlin-версия Javadoc) и генерирует HTML, Markdown или Javadoc-совместимые отчёты.

Пример KDoc:

/**
 * Загружает пользователя по идентификатору.
 *
 * @param id числовой идентификатор пользователя
 * @return [User], если найден, иначе выбрасывает [UserNotFoundException]
 * @throws UserNotFoundException если пользователь не существует
 */
suspend fun getUser(id: Long): User

Dokka интегрируется с Gradle и Maven, поддерживает многомодульные проекты и может публиковать документацию на GitHub Pages или внутренние порталы знаний.

Detekt​

Detekt — это статический анализатор кода для Kotlin. Он проверяет стиль, архитектурные нарушения, потенциальные баги и anti-patterns.

Detekt настраивается через YAML-файл и поддерживает кастомные правила. Он интегрируется в CI/CD и IDE.

Пример конфигурации:

style:
  MagicNumber:
    active: true
    ignoreNumbers: ["-1", "0", "1"]
  MaxLineLength:
    active: true
    maxLineLength: 120

Detekt помогает поддерживать единый стиль кода в команде, выявлять сложные методы, избыточные условия и другие проблемы до попадания в репозиторий.

6. Экспериментальные и нишевые направления​

Kotlin-сообщество активно исследует новые способы использования языка за пределами традиционных платформ. Эти эксперименты часто становятся основой для будущих стандартов или решают узкие, но важные задачи в специализированных доменах.

Kotlin/Wasm​

Kotlin/Wasm — это экспериментальный компилятор Kotlin в WebAssembly (Wasm), разрабатываемый JetBrains. Цель — позволить запускать Kotlin-код в браузере с производительностью, близкой к нативной, без промежуточного слоя JavaScript.

WebAssembly — это бинарный формат выполнения, поддерживаемый всеми современными браузерами. Он обеспечивает быстрый запуск, изоляцию и совместимость.

Kotlin/Wasm пока не стабилен, но уже позволяет:

  • Компилировать простые Kotlin-программы в .wasm-модули.
  • Вызывать Wasm-функции из JavaScript и наоборот.
  • Использовать общий код между сервером и клиентом без транспиляции в JS.

Пример гипотетического использования (на основе текущих прототипов):

// commonMain
fun calculateFibonacci(n: Int): Int {
    return if (n <= 1) n else calculateFibonacci(n - 1) + calculateFibonacci(n - 2)
}

Эта функция может быть скомпилирована в Wasm и вызвана из HTML:

<script type="module">
  import init from './kotlin-wasm.js';
  const { calculateFibonacci } = await init();
  console.log(calculateFibonacci(30));
</script>

Kotlin/Wasm открывает путь к высокопроизводительным веб-приложениям: играм, CAD-редакторам, аудио/видео-обработке — всему, где JavaScript оказывается недостаточным.

Project Loom + Kotlin Coroutines​

Project Loom — это инициатива OpenJDK по внедрению легковесных потоков (virtual threads) в JVM. Virtual threads управляются самой виртуальной машиной и позволяют запускать миллионы одновременных задач без перегрузки ОС-потоков.

Kotlin Coroutines и Project Loom решают одну и ту же проблему — эффективное управление параллелизмом — но разными способами. Однако они могут дополнять друг друга.

Например, корутины могут использовать virtual threads как исполнительную среду:

val dispatcher = ExecutorCoroutineDispatcher {
    Executors.newVirtualThreadPerTaskExecutor()
}

launch(dispatcher) {
    // Этот блок выполняется в virtual thread
    val data = blockingIoCall() // теперь безопасно блокировать
    process(data)
}

Такая комбинация упрощает написание блокирующего кода без потери масштабируемости. Это особенно полезно при миграции legacy-систем или работе с библиотеками, не поддерживающими асинхронность.

JetBrains и сообщество Kotlin активно исследуют эту интеграцию, чтобы обеспечить плавный переход к эпохе Loom.

KVision​

KVision — это full-stack фреймворк для создания веб-приложений на Kotlin. Он позволяет писать и клиентский, и серверный код на одном языке, используя React-подобную модель компонентов.

KVision основан на Kotlin/JS (IR) и предоставляет:

  • Типобезопасные UI-компоненты (кнопки, таблицы, формы).
  • Интеграцию с Bootstrap, Material Design, FontAwesome.
  • Роутинг, состояние, события.
  • Прямую связь с сервером через Ktor или Spring Boot.

Пример компонента:

class MainView : SimplePanel() {
    init {
        add(
            VPanel {
                h1 { +"Добро пожаловать в KVision!" }
                button("Нажми меня") {
                    onClickFunction = {
                        alert("Привет из Kotlin!")
                    }
                }
            }
        )
    }
}

KVision особенно ценен для команд, стремящихся к максимальному переиспользованию кода и единообразию архитектуры. Хотя он менее известен, чем Compose Multiplatform, он остаётся мощным решением для enterprise-веба.

Multiplatform Settings​

Multiplatform Settings — это библиотека для хранения пользовательских настроек (preferences) в мультиплатформенных приложениях. Она предоставляет единый API для работы с:

  • SharedPreferences (Android)
  • UserDefaults (iOS)
  • localStorage / sessionStorage (JavaScript)
  • Hocon / JSON-файлы (Desktop)

Пример использования:

val settings = Settings()

settings.putString("username", "Екатерина")
val name = settings.getString("username", "Гость")

Библиотека поддерживает реактивность через Flow, шифрование, миграции и вложенные объекты. Она решает одну из самых частых задач в KMM-проектах — сохранение состояния между сессиями — без необходимости писать платформенный код.